src/components/Messages.tsx (1)

817-822: Hoist DIFF_COLLAPSE_DISTANCE to module scope and clarify the comment.

DIFF_COLLAPSE_DISTANCE is a tuning knob declared inside renderMessageRow (re-created on every row), and with the current value 0 the comment "beyond the latest N messages" reads as if multiple recent messages stay verbose — only the single last one does. Hoisting it next to MAX_MESSAGES_WITHOUT_VIRTUALIZATION / MESSAGE_CAP_STEP makes it discoverable and tunable.

♻️ Suggested refactor

 const MAX_MESSAGES_WITHOUT_VIRTUALIZATION = 200
 const MESSAGE_CAP_STEP = 50
+
+// Tool-result diffs are collapsed for every message except the last
+// DIFF_COLLAPSE_DISTANCE messages (verbose / ctrl+o overrides). Set to 0
+// so only the most recent tool_result keeps its full diff — older diffs
+// drop to 'condensed' to reduce memory peak on large transcripts.
+const DIFF_COLLAPSE_DISTANCE = 0

-    // Collapse diffs for messages beyond the latest N messages.
-    // verbose (ctrl+o) overrides and always shows full diffs.
-    const DIFF_COLLAPSE_DISTANCE = 0
     const shouldCollapseDiffs =
       renderableMessages.length - 1 - index > DIFF_COLLAPSE_DISTANCE

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/components/Messages.tsx` around lines 817 - 822, Hoist the
DIFF_COLLAPSE_DISTANCE constant out of renderMessageRow to module scope next to
MAX_MESSAGES_WITHOUT_VIRTUALIZATION and MESSAGE_CAP_STEP so it isn't re-created
per row and is easier to tune; update the inline comment where
DIFF_COLLAPSE_DISTANCE is used to accurately describe behavior (e.g. "Collapse
diffs for messages beyond the latest N messages; when N=0 only the most recent
message remains expanded") and keep the existing usage of shouldCollapseDiffs =
renderableMessages.length - 1 - index > DIFF_COLLAPSE_DISTANCE unchanged so the
logic still references the hoisted constant.

src/services/api/claude.ts (2)

2554-2556: Optional: extract the duplicated thinkingBudgetTokens spread.

The same conditional appears three times (disabled-fallback path, normal-fallback path, 404-fallback path). A small helper would tidy this up, but it's purely cosmetic.

const thinkingAnalyticsFields =
  thinkingConfig.type === 'enabled'
    ? { thinkingBudgetTokens: thinkingConfig.budgetTokens }
    : {}

…then ...thinkingAnalyticsFields at the three sites.

Also applies to: 2589-2591, 2708-2710

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/services/api/claude.ts` around lines 2554 - 2556, Extract the duplicated
conditional spread for thinkingBudgetTokens into a small helper object (e.g.,
create thinkingAnalyticsFields) so you only compute it once from thinkingConfig:
set thinkingAnalyticsFields = thinkingConfig.type === 'enabled' ? {
thinkingBudgetTokens: thinkingConfig.budgetTokens } : {} and then replace the
three occurrences of ...(thinkingConfig.type === 'enabled' && {
thinkingBudgetTokens: thinkingConfig.budgetTokens }) (the disabled-fallback,
normal-fallback and 404-fallback sites) with ...thinkingAnalyticsFields; keep
the symbol names thinkingConfig and thinkingBudgetTokens unchanged so the
refactor is minimal and local.

---

1782-1793: Inconsistent field naming with peer providers — consider normalizing to budgetTokens for consistency.

langfuseThinking captures queryParams.thinking directly, which uses budget_tokens (snake_case from the Anthropic SDK). However, recordLLMObservation accepts both budget_tokens and budgetTokens (per its type signature and JSDoc at src/services/langfuse/tracing.ts lines 81–90), so this will work without issue.

That said, every other provider normalizes to camelCase before passing to recordLLMObservation:

• src/services/api/gemini/index.ts (lines 196-204): { type, budgetTokens }
• src/utils/sideQuery.ts (lines 297-302): { type, budgetTokens: thinkingConfig.budget_tokens }
• src/services/tokenEstimation.ts (line 357): { type: 'enabled', budgetTokens }

Aligning claude.ts to this pattern improves consistency and avoids relying on the permissive dual-format acceptance.

Optional: Normalize to match peer providers

-  let langfuseThinking: BetaMessageStreamParams['thinking'] | undefined
+  let langfuseThinking:
+    | { type: 'enabled'; budgetTokens: number }
+    | { type: 'adaptive' }
+    | undefined
   {
     const queryParams = paramsFromContext({
       model: options.model,
       thinkingConfig,
     })
     const logMessagesLength = queryParams.messages.length
     const logBetas = useBetas ? (queryParams.betas ?? []) : []
     const logEffortValue = queryParams.output_config?.effort
-    if (queryParams.thinking && queryParams.thinking.type !== 'disabled') {
-      langfuseThinking = queryParams.thinking
-    }
+    if (queryParams.thinking?.type === 'enabled') {
+      langfuseThinking = {
+        type: 'enabled',
+        budgetTokens: queryParams.thinking.budget_tokens,
+      }
+    } else if (queryParams.thinking?.type === 'adaptive') {
+      langfuseThinking = { type: 'adaptive' }
+    }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/services/api/claude.ts` around lines 1782 - 1793, langfuseThinking is set
directly from queryParams.thinking which uses snake_case (budget_tokens), but
other providers normalize to camelCase; update the block that assigns
langfuseThinking (in the function that calls paramsFromContext and uses
thinkingConfig) to map thinking.budget_tokens to thinking.budgetTokens (i.e.,
produce { type, budgetTokens } or equivalent) before passing into
recordLLMObservation so the Claude path matches the camelCase shape used by
gemini/index.ts, sideQuery.ts and tokenEstimation.ts and avoids relying on
dual-format acceptance.

packages/builtin-tools/src/tools/FileEditTool/utils.ts (1)

121-128: Combined branch re-normalizes whitespace over already-quote-normalized strings — harmless but redundant.

Lines 122-123 call normalizeWhitespace(normalizedFile) and normalizeWhitespace(normalizedSearch), where both inputs were produced earlier (lines 100-101). Quote normalization doesn't introduce or remove tabs, so combinedFile === wsNormalizedFile whenever no curly quotes exist and is a strict superset transformation otherwise. You can compute each normalization once and reuse, e.g. const combinedFile = normalizeQuotes(wsNormalizedFile) (and likewise for the search), avoiding one extra full-string traversal per call. Minor on small files; matters for very large ones where this is a hot path.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/builtin-tools/src/tools/FileEditTool/utils.ts` around lines 121 -
128, The combined-branch is redundantly calling
normalizeWhitespace(normalizedFile) and normalizeWhitespace(normalizedSearch)
where normalizedFile/normalizedSearch were produced earlier; instead reuse the
already-whitespace-normalized values (wsNormalizedFile, wsNormalizedSearch) and
apply quote normalization once: replace combinedFile =
normalizeWhitespace(normalizedFile) with combinedFile =
normalizeQuotes(wsNormalizedFile) and combinedSearch =
normalizeQuotes(wsNormalizedSearch), keeping the subsequent combinedIndex and
mapNormalizedMatchBackToFile usage unchanged.

packages/builtin-tools/src/tools/FileEditTool/__tests__/utils.test.ts (1)

109-187: Coverage gap: ratio-fallback edge case in mapNormalizedMatchBackToFile is not exercised.

Every test where the match extends to the end of fileContent happens to also match the entire file starting at offset 0, which makes the origEnd === -1 ratio-heuristic in mapNormalizedMatchBackToFile resolve to the correct value by coincidence (ratio * normalizedLength === fileContent.length). A case like a partial trailing match in a file whose tab density is non-uniform (e.g. "\t\t\t\t\t\t\t\t\t\there" searched with " here") would expose the truncation bug noted on utils.ts. Consider adding such a case once the underlying mapping is hardened.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/builtin-tools/src/tools/FileEditTool/__tests__/utils.test.ts` around
lines 109 - 187, Add a unit test that reproduces the ratio-fallback edge-case in
mapNormalizedMatchBackToFile by using a fileContent with highly non-uniform tab
density (e.g. many leading tabs then text) and a search string with spaces for
the same trailing text (example: fileContent = "\t\t\t\t\t\t\t\t\t\there" and
searchSpaces = "    here"); use findActualString to locate the match and assert
the result is not null, that fileContent.includes(result!), and that the
returned substring equals the actual trailing slice of fileContent (so the test
fails if origEnd === -1 mapping truncates/miscomputes the end). Ensure the new
test is named clearly (e.g. "handles ratio-fallback for trailing partial
matches") and placed in the same utils.test.ts block covering tab/space
normalization to exercise mapNormalizedMatchBackToFile.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes